#include <iostream>
#include <string>
#include <vector>
#include <queue>
/*
    走出迷宫问题
    不带权的bfs，相当于树的遍历,使用队列的方式
    1. 使用结构体定义移动点
    2. 使用队列储存需要遍历的父节点
    3. 是否有解不能用total < T即当前树的深度来做判断条件，因为total > T并不能说明后续的路径无解，
    只 是说明当前这颗子树深度过长了。应该判断队列是否为空来看是否走完所有子树
    4. 走过的点要打上标记，以防重复走陷入死循环
    5. 不用处理不能走的情况，能走的情况全部列出来后，如果不能走就会自动进入下一次循环，排出队列的下一个点走
*/
using namespace std;
char maze[10][10];
struct node
{
    int x, y, step;
    node(int xx, int yy, int T)
    {
        x = xx;
        y = yy;
        step = T;
    }
};

bool bfs(node start, int T, int m)
{
    int total, x, y;
    queue<node> node_que;
    node_que.push(start);
    node pre_node(0, 0, 0);
    while (!node_que.empty()) // 不能用total < T来做判断条件，因为total > T并不能说明后续的路径无解，只是说明当前这颗子树深度过长了
    {
        pre_node = node_que.front();
        total = pre_node.step, x = pre_node.x, y = pre_node.y;
        maze[pre_node.x][pre_node.y] = 'S'; // 走过的路赋值为S，不再重复走
        node_que.pop();
        // x,y为行列
        // 向上走
        if (x >= 1 && maze[pre_node.x - 1][pre_node.y] != 'S') // 判断能否向上走和是否走过
        {
            x = pre_node.x - 1;
            y = pre_node.y;
            total = pre_node.step + 1;
            if (maze[x][y] == '.')
            {
                node_que.push(node(x, y, total));
            }
            else if (maze[x][y] == 'E')
            {
                return true;
            }
        }
        // 向下走
        if (x < m - 1 && maze[pre_node.x + 1][pre_node.y] != 'S')
        {
            x = pre_node.x + 1;
            y = pre_node.y;
            total = pre_node.step + 1;
            if (maze[x][y] == '.')
            {
                node_que.push(node(x, y, total));
            }
            else if (maze[x][y] == 'E')
            {
                return true;
            }
        }
        // 向左走
        if (y >= 1 && maze[pre_node.x][pre_node.y - 1] != 'S')
        {
            x = pre_node.x;
            y = pre_node.y - 1;
            total = pre_node.step + 1;
            if (maze[x][y] == '.')
            {
                node_que.push(node(x, y, total));
            }
            else if (maze[x][y] == 'E')
            {
                return true;
            }
        }
        // 向右走
        if (y < m - 1 && maze[pre_node.x][pre_node.y + 1] != 'S')
        {
            x = pre_node.x;
            y = pre_node.y + 1;
            total = pre_node.step + 1;
            if (maze[x][y] == '.')
            {
                node_que.push(node(x, y, total));
            }
            else if (maze[x][y] == 'E')
            {
                return true;
            }
        }
    }
    return false;
}

int main()
{
    int K, m, T, x1, y1, x2, y2;
    cin >> K;
    char c;
    // m组迷宫数组的输入
    while (K--)
    {
        cin >> m >> T;
        for (size_t i = 0; i < m; i++)
        {
            for (size_t j = 0; j < m; j++)
            {
                cin >> c;
                maze[i][j] = c;
                if (c == 'S')
                {
                    x1 = i;
                    y1 = j;
                }
            }
        }
        node start(x1, y1, 0);
        if (bfs(start, T, m))
        {
            cout << "Yes" << endl;
            for (size_t i = 0; i < m; i++)
            {
                for (size_t j = 0; j < m; j++)
                {
                    cout << maze[i][j] << " ";
                }
                cout << endl;
            }
        }
        else
        {
            cout << "No" << endl;
            for (size_t i = 0; i < m; i++)
            {
                for (size_t j = 0; j < m; j++)
                {
                    cout << maze[i][j] << " ";
                }
                cout << endl;
            }
        }
    }
}